package com.huawei.ju;

/**
 * @description 最小循环子数组
 *  题目描述:
 *    给定一个由若干整数组成的数组nums，请检查数组是否是由某个子数组重复循环拼接而成，请输出这个最小的子数组。输入描述:
 *      第一行输入数组中元素个数n,1<=n<=100000
 *      第二行输入数组的数字序列nums，以空格分割，0<= nums[i]<10;输出描述:
 *    输出最小的子数组的数字序列，以空格分割;补充说明:
 *    数组本身是其最大的子数组，循环1次可生成的自身;
 *    示例1 输入:9， 1 2 1 1 2 1 1 2 1 输出:121
 *    说明:
 *      数组[1,2,1,1,2,1,1,2,1]可由子数组[1,2,1]重复循环3次拼接而成
 * @author wj
 * @date 2023-10-20
 */
public class MinChildLoopArray {

  public static void main(String[] args) {
    String minLoopSingleCharArrayStr = getMinLoopSingleCharArrayStr(9, "1 2 1 1 2 1 1 2 1");
    System.out.println(minLoopSingleCharArrayStr);
    String minLoopMultiCharArrayStr = getMinLoopMultiCharArrayStr(6, "12 11 12 11 12 11");
//    String minLoopMultiCharArrayStr = getMinLoopMultiCharArrayStr(12, "1 2 1 1 2 1 1 2 1 1 2 1");
    System.out.println(minLoopMultiCharArrayStr);
  }

  /**
   * 获取最小的循环数组
   * @param size 数组元素
   * @param originArrayStr 原始输入的数组
   * @return 最小循环数组
   * @author wj
   * @date 2023/10/23
   */
  private static String getMinLoopSingleCharArrayStr(int size, String originArrayStr) {
    if (originArrayStr == null || "".equals(originArrayStr.trim())) {
      return originArrayStr;
    }
    originArrayStr = originArrayStr.replace(" ", "");
    String minSectionStr = null;
    if (originArrayStr.length() == size) {
      for (int i = size; i > 0; i--) {
        if (size % i == 0) {
          String tempSectionStr = originArrayStr.substring(0, i);
          if (originArrayStr.split(tempSectionStr).length == 0) {
            minSectionStr = tempSectionStr;
          }
        }
      }
    }
    return minSectionStr;
  }

  /**
   * 获取最小的循环数组
   * @param size 数组元素
   * @param originArrayStr 原始输入的数组
   * @return 最小循环数组
   * @author wj
   * @date 2023/10/23
   */
  private static String getMinLoopMultiCharArrayStr(int size, String originArrayStr) {
    if (originArrayStr == null || "".equals(originArrayStr.trim())) {
      return originArrayStr;
    }
    String[] originArr = originArrayStr.split(" ");
    if (originArr.length == size) {
      int tempLength;
      int tempCount;
      for (int i = 0; i < size; i++) {
        tempLength = i + 1;
        boolean interruptFlag = false;
        if (size % tempLength == 0) {
          StringBuilder minSectionStr = new StringBuilder();
          tempCount = size / tempLength;
          for (int j = 0; j <= i; j++) {
            String originArrJ = originArr[j];
            minSectionStr.append(originArrJ);
            for (int m = 1; m < tempCount; m++) {
              String originArrRepeat = originArr[j + tempLength * m];
              if (!originArrJ.equals(originArrRepeat)) {
                interruptFlag = true;
                break;
              }
            }
            if (interruptFlag) {
              break;
            }
          }
          if (!interruptFlag) {
           return minSectionStr.toString();
          }
        }
      }
    }
    return null;
  }
}
